let uuid = require("uuid");

/**
 * 加工分页参数
 * @param {Object} data 
 */
exports.setupPage = function (data, inOrder = "update_time desc") {

    // 页数
    let page = data.page || 1;
    // 每页行数
    let rows = data.rows || 5;

    let order = data.order || inOrder;
    data.order = order;


    // 避免行数过大
    if (rows >= 50) {
        rows = 50;
        // 避免行数过小
    } else if (rows <= 0) {
        rows = 5;
    }
    data.page = page;
    data.rows = rows;
    data.begin = (page - 1) * rows;
    // 表示打开分页功能
    data.paging = true;
}


/**
 * 返回成功结果对象
 * @param {any} result_data 结果
 * @param {string} msg 消息，默认为"操作成功"
 * @param {int} status 状态码，默认为1
 * @returns 
 */
exports.successResult = function (result_data,
    msg = "操作成功",
    status = 1) {
    return result(result_data,msg,status)
}

/**
 * 返回失败结果对象
 * @param {any} result_data 结果
 * @param {string} msg 消息，默认为"操作失败"
 * @param {int} status 状态码，默认为-1
 * @returns 
 */
exports.failedResult = function (result_data,
    msg = "操作失败",
    status = -1) {
    return result(result_data,msg,status)
}

/**
 * 返回结果对象
 * @param {any} result_data 结果
 * @param {string} msg 消息
 * @param {int} status 状态码
 * @returns 
 */
exports.result = function(result_data,msg,status) {
    return {
        status,
        msg,
        result_data
    }
}

// 缓存所有的用户
const userMap = new Map();

// 每三分钟校验一次用户是否过期。
setInterval(() => {
    let time = new Date().getTime();
    userMap.forEach((v,k) => {
        // 如果过期时间小于当前时间：过期（删除当前数据）
        if (v.expire < time) {
            userMap.delete(k);
        }
    })
},1000 * 60 * 3);


/**
 * 计算用户token，并将token值添加到user对象上，并将用户缓存起来
 * @param {*} user 用户信息
 */
exports.saveUser = function(user
    ,pk_key = "t_admin_pk"
    ,preStr = "ADM") {
    // 获取当前用户主键
    let pk = user[pk_key];
    // ADM用户主键-
    // 判断当前用户是否已经缓存
    let key = Array.from(userMap.keys()).find(v => v.startsWith(preStr + pk + "-"));
    // 做法一：如果查询出已经缓存的有数据，把以前的数据删除
    // 做法二：如果查询出已经缓存的有数据，继续使用以前的token
    // 这里采用做法二：一个账户，可以多个人同时登录
    if (key) {
        user.token = key;
        return key;
    } else {
        // 计算token
        //   方案一：token就是一个简单的随机字符串，以该字符串为key，其余信息为value，缓存下来
        //   方案二：token已经保存了用户的所有信息，token需要严格加密传输
        // 这里采用方案一
        let token = preStr + pk + "-" + uuid.v4();
        // 失效时间：七天
        let time = new Date().getTime() + 1000 * 3600 * 24 * 7;
        user.expire = time;
        user.token = token;
        userMap.set(token,user);
        console.log("userMap1 = ",userMap);
        return key;
    }
}

exports.removeUser = function(token) {
    userMap.delete(token);
}

/**
 * 校验当前token是否合法
 * @param {string} token 
 * @return
 */
exports.hasFun = function(req,res) {
    let token = req.headers["authorition"];
    let url = req.originalUrl;
    // 未传入token无效 = 未登录
    if (!token) {
        res.json({
            status: -10,
            msg: "当前用户未登录"
        })
        return false;
    }
    let user = userMap.get(token);
    // 传入token无效 = 未登录
    if (!user) {
        res.json( {
            status: -10,
            msg: "当前用户未登录", 
        })
        return false;
    }
    // 在当前登录用户的url地址中，判断是否包含当前的url
    let hasFun = user.funSet.some(v => url.endsWith(v));
    if (!hasFun) {
        res.json( {
            status: -16,
            msg: "没有操作权限", 
        })
        return false;
    }
    // 失效时间：延长七天
    let time = new Date().getTime() + 1000 * 3600 * 24 * 7;
    user.expire = time;
    return {
        ...req.body,
        admin_pk: user.t_admin_pk,
    }
}